#include "Voleur.h"

using namespace std;
using namespace boost::assign;

/**
 * Contient les valeurs de base des talents de voleur. Un '100' signifie que
 * La compétence n'est pas associée à un pourcentage.
 */
const vector<unsigned int> Voleur::comp_base = list_of
  (100)(5)(10)(10)(15)(5)(10)(100)(10)(60)(100)
  (0)(15)(5)(100)(100)(5)(15)(100)(100)(100);

const unsigned int Voleur::nbr_comp = 21;

const unsigned int Voleur::nbr_restric = 0;

const vector<ListComp> Voleur::Comp = list_of
  (ListComp("Attaque sournoise"                 , 10, Basique))
  (ListComp("Corruption"                        ,  5, true ,  5))
  (ListComp("Crocheter les serrures"            , 10, true , 10))
  (ListComp("Déplacement silencieux"            ,  5, true , 10))
  (ListComp("Détection des bruits"              ,  5, true , 15))
  (ListComp("Détection de la magie"             , 10, true ,  5))
  (ListComp("Détection des illusions"           , 10, true , 10))
  (ListComp("Esquive"                           , 10))
  (ListComp("Evasion"                           , 10, true , 10))
  (ListComp("Grimper"                           ,  5, true , 60))
  (ListComp("Jargon des voleurs"                ,  5))
  (ListComp("Lire des langues inconnues"        ,  5, true ,  0))
  (ListComp("Percer un tunnel"                  , 10, true , 15))
  (ListComp("Se cacher dans l'ombre"            ,  5, true ,  5))
  (ListComp("Suivant (niveau 10)"               ,  5))
  (ListComp("Suivants"                          , 10))
  (ListComp("Trouver et désamorcer les pièges"  , 10, true ,  5))
  (ListComp("Vol à la tire"                     , 10, true , 15))
  (ListComp("Utilisation de parchemins (niv 10)",  5, Pourcentage))
  (ListComp("Utilisation de parchemins"         , 10, Pourcentage))
  (ListComp("Specialisation"                    , 15));

const vector< Prerequis > Voleur::Limites = list_of
  (Prerequis(1, 9));

const set< string > Voleur::RacesAdmises = list_of
  ( "Humain" ) ( "Demi-Elfe" ) ( "Demi-Ogre" ) ( "Demi-Orque" )
  ( "Elfe" ) ( "Gnome" ) ( "Hobbit" ) ( "Nain" );

/** Constructeur usuel.
 * Permet la construction d'un voleur de A à Z, càd on détermine ici
 * les restrictions, puis les compétences.
 * @param xp le nombre de pts d'expérience du Voleur.
 * @param trait les traits du Voleur, le 7ème contient le score de
 * force exceptionnel, fixé à 0 si non applicable.
 * @param PP nombre de points de personnage (PP) à disposition pour la
 * céation du Voleur.
 * @param race nom de la race du personnage.
 */
Voleur::Voleur(unsigned int xp, const vector< unsigned int >& trait,
	       unsigned int& PP, const string& race)
  : Classe(xp, trait, Roublards, race)
{
  Debug::empileNiveau( &elementaire );

  Type_classe = "Voleur";
  PP += 80;

  NombreTotalCompetences  = nbr_comp;
  NombreTotalRestrictions = nbr_restric;
  NombreTotalEnsembles    = 0;
  NombreMaxCompetences    = 0;
  ListesCompetences       = list_of< vector< ListComp > >( Comp );
  PrerequisClasse         = list_of< vector< Prerequis > >( Limites );
  RacesAdmisesClasse      = list_of< set< string > >( RacesAdmises );

  blank() << setfill('*') << setw(56) << '*' << endreq;
  blank() << "Création d'un voleur" << endl << endreq;

  construitClasse( PP );

//   unsigned int nbr(0);

//   blank() << "Tu as " << PP << " pp à dépenser" << endreq;

//   for (unsigned int i(0); i<nbr_comp; i++)
//     blank() << i+1 << ' ' << Comp[i].Comp << " (" << Comp[i].Cout
// 		<< " pp)" << endreq;	
//   blank() << nbr_comp+1 << " Aucune" << endreq;
//   blank() << "Choisir les compétences de classe" << endreq;

//   bool test(true), deja_pris, encore(false);
//   unsigned int save_PP(PP);
//   vector<unsigned int> oublier;

//   do
//     {
//       do
// 	{
// 	  nbr = demanderUnsignedBorne("("+ecrireString(PP)+" PP restants) ", 1,
// 					nbr_comp + 1);
// 	  if (nbr!=nbr_comp+1)
// 	    {
// 	      if (PP >= Comp[nbr-1].Cout)
// 		{
// 		  deja_pris = safePushBack(&Comp_classe, nbr - 1,
// 					     oublier);
// 		  if (deja_pris)
// 		    warning() << "Déjà sélectrionné" << endreq;
// 		  else
// 		    {
// 		      Comp_classe.push_back(nbr-1);
// 		      PP -= Comp[nbr-1].Cout;
// 		      blank() << "Compétence choisie : " << Comp[nbr-1].Comp 
// 				  << endreq;
// 		      if (Comp[nbr-1].Pourcentage)
// 			{
// 			  oublier.push_back(Comp_classe.size());
// 			  debug() << "oublier " << oublier.back() << endreq;
// 			  Comp_classe.push_back(comp_base[nbr-1]);
// 			  debug() << nbr-1 << " => " << Comp[nbr-1].Comp
// 				      << " " << comp_base[nbr-1] << endreq;
// 			}
// 		      else
// 			debug() << nbr-1 << " => " << Comp[nbr-1].Comp << endreq;
// 		    }
// 		}
// 	      else
// 		blank() << "Pas assez de pp" << endreq;
// 	    }
// 	  else
// 	    test = false;
// 	}
//       while(test);

//       afficheCompetences();
//       blank() << endl <<  "1 pour continuer, 2 pour recommencer" << endreq;
//       nbr = demanderUnsignedBorne("Choix ", 1, 2);
//       if (nbr == 2)
// 	{
// 	  PP = save_PP;
// 	  Comp_classe.clear();
// 	  test = true;
// 	  encore = true;
// 	  blank() << endreq;
// 	}
//       else
// 	encore = false;
//     }
//   while(encore);

  blank() << endl << setfill('*') << setw(56) << '*' << endreq;
  calculNiveau();
  augmenterTalents(false);

  Debug::depileNiveau();//dout.setLevel(etat_precedent);
}

/** Constructeur simplifié.
 * Permet de construire un Voleur lors de la lecture d'un ficier xml.
 * @param xp le nombre de pts d'expérience du Voleur.
 * @param trait les traits du Voleur, le 7ème contient le score de
 * force exceptionnel, fixé à 0 si non applicable.
 * @param race nom de la race du personnage.
 */
Voleur::Voleur(unsigned int xp, const vector< unsigned int >& trait,
	       const string& race)
  : Classe(xp, trait, Roublards, race)
{
  Type_classe = "Voleur";

  NombreTotalCompetences  = nbr_comp;
  NombreTotalRestrictions = nbr_restric;
  NombreTotalEnsembles    = 0;
  NombreMaxCompetences    = 0;
  ListesCompetences       = list_of< vector< ListComp > >( Comp );
  PrerequisClasse         = list_of< vector< Prerequis > >( Limites );
  RacesAdmisesClasse      = list_of< set< string > >( RacesAdmises );

  calculNiveau();
}

/** Constructeur pour le mode graphique.
 * Permet de construire une instance de Mage avec le contenu
 * minimal, le nombre de points d'expériences et les capacités étant
 * déterminées après la déclaration.
 *
 * @param trait les traits du Mage, le 7ème contient le score de
 * force exceptionnel, fixé à 0 si non applicable.
 * @param UI contrôle, est présent pour des raisons historiques.
 * @param race nom de la race du personnage.
 */
Voleur::Voleur(const vector< unsigned int >& trait, const bool& UI,
	       const string& race)
  : Classe(0, trait, Roublards, race)
{
  if (!UI)
    {
      error() << "Création du personnage impossible" << endreq;
      exit(1);
    }

  Type_classe = "Voleur";

  NombreTotalCompetences  = nbr_comp;
  NombreTotalRestrictions = nbr_restric;
  NombreTotalEnsembles    = 0;
  NombreMaxCompetences    = 0;
  ListesCompetences       = list_of< vector< ListComp > >( Comp );
  PrerequisClasse         = list_of< vector< Prerequis > >( Limites );
  RacesAdmisesClasse      = list_of< set< string > >( RacesAdmises );

  calculNiveau();
}

/**
 * Constructeur de "copie", destiné à être utilisé depuis MetaClasse.
 *
 * @param ptr pointeur sur un objet de type Classe (MetaClasse en
 * fait).
 */
Voleur::Voleur(Classe *ptr)
  : Classe( *ptr )
{
  Type_classe = "Voleur";

  NombreTotalCompetences  = nbr_comp;
  NombreTotalRestrictions = nbr_restric;
  NombreTotalEnsembles    = 0;
  NombreMaxCompetences    = 0;
  ListesCompetences       = list_of< vector< ListComp > >( Comp );
  PrerequisClasse         = list_of< vector< Prerequis > >( Limites );
  RacesAdmisesClasse      = list_of< set< string > >( RacesAdmises );

  calculNiveau();
}

/**
 * Destructeur, ne fait rien de spécial
 */
Voleur::~Voleur()
{}

void Voleur::calculNiveau()
{
  if (XP < 75000)
    {
      unsigned int i;
      for (i = 0; i < 5; i++)
	{
	  if (XP < (unsigned int) 1250 * puissance(2, i))
	    break;
	}
      Niveau = i + 1;
    }
  else if (XP < 70000)
    Niveau = 7;
  else if (XP < 110000)
    Niveau = 8;
  else if (XP < 160000)
    Niveau = 9;
  else if (XP < 220000)
    Niveau = 10;
  else
      Niveau = (XP - 220000) / 220000 + 11;
}

// /**
//  * Ici il faut faire attention aux pourcentages.
//  */
// void Voleur::afficher_stats(ostream& os)
// {
//   os << "Voleur" << endreq;
//   for (unsigned int i(0); i<6; i++)
//     os << Caracteristiques[i] << ' ' << Traits[i] << endreq;
//   for (unsigned int i(0); i<Comp_classe.size(); i++)
//     {
//       if(Comp[Comp_classe[i]].Pourcentage)
// 	{
// 	  os << Comp[Comp_classe[i]].Comp << ' ' << Comp_classe[i+1];
// 	  os << '%' << endreq;
// 	  i++;
// 	}
//       else
// 	os << Comp[Comp_classe[i]].Comp << endreq;
//     }
// }

/**
 * Ici sont appliqués les modifications aux talents de voleur dues à
 * la Race et à la Dextérité.
 */
void Voleur::appliquerModif()
{
  Debug::empileNiveau( &fonction );
  func() << "Voleur::appliquerModif -> début" << endreq;

  vector< int > *comp_bonus;

  determinerScoresAjustes( Type_race, Traits[1], comp_bonus );
  
//   if (type == "Nain")
//     {
//       comp_bonus[1]  -= 5;   // corruption
//       comp_bonus[2]  += 10;  // crochetage
//       comp_bonus[5]  += 5;   // détection de la magie
//       comp_bonus[6]  += 5;   // détection des illusions
//       comp_bonus[9]  -= 10;  // escalade
//       comp_bonus[11] -= 5;   // lire des langues inconnues
//       comp_bonus[12] += 10;  // creuser des tunnels
//       comp_bonus[16] += 15;  // trouver et désamorcer les pièges
//     }
//   else if (type == "Elfe")
//     {
//       comp_bonus[1]  += 15;  // corruption
//       comp_bonus[2]  -= 5;   // crochetage
//       comp_bonus[3]  += 5;   // mouvement silencieux
//       comp_bonus[4]  += 5;   // détection des bruits
//       comp_bonus[5]  += 10;  // détection de la magie
//       comp_bonus[12] -= 10;  // creuser des tunnels
//       comp_bonus[13] += 10;  // se cacher dans l'ombre
//       comp_bonus[17] += 5;   // vol à la tire
//     }
//   else if (type == "Gnome")
//     {
//       comp_bonus[1]  += 5;   // corruption
//       comp_bonus[2]  += 5;   // crochetage
//       comp_bonus[3]  += 5;   // mouvement silencieux
//       comp_bonus[4]  += 10;  // détection des bruits
//       comp_bonus[5]  += 5;   // détection de la magie
//       comp_bonus[6]  += 10;  // détection des illusions
//       comp_bonus[9]  -= 15;  // escalade
//       comp_bonus[12] += 5;   // creuser des tunnels
//       comp_bonus[13] += 5;   // se cacher dans l'ombre
//       comp_bonus[16] += 10;  // trouver et désamorcer les pièges
//     }
//   else if (type == "Demi-Elfe")
//     {
//       comp_bonus[1]  += 5;   // corruption
//       comp_bonus[5]  += 5;   // détection de la magie
//       comp_bonus[6]  += 5;   // détection des illusions
//       comp_bonus[12] -= 5;   // creuser des tunnels
//       comp_bonus[13] += 5;   // se cacher dans l'ombre
//       comp_bonus[17] += 10;  // vol à la tire
//     }
//   else if (type == "Demi-Orque")
//     {
//       comp_bonus[1]  += 10;  // corruption
//       comp_bonus[4]  += 5;   // détection des bruits
//       comp_bonus[6]  -= 5;   // détection des illusions
//       comp_bonus[16] += 5;   // trouver et désamorcer les pièges
//     }
//   else if (type == "Hobbit")
//     {
//       comp_bonus[2]  += 5;   // crochetage
//       comp_bonus[3]  += 10;  // mouvement silencieux
//       comp_bonus[4]  += 5;   // détection des bruits
//       comp_bonus[5]  += 5;   // détection de la magie
//       comp_bonus[8]  += 10;  // évasion
//       comp_bonus[9]  -= 15;  // escalade
//       comp_bonus[11] -= 5;   // lire des langues inconnues
//       comp_bonus[12] += 5;   // creuser des tunnels
//       comp_bonus[13] += 15;  // se cacher dans l'ombre
//       comp_bonus[16] += 5;   // trouver et désamorcer les pièges
//       comp_bonus[17] += 5;   // vol à la tire
//     }

//   switch(Traits[1])
//     {
//     case 9:
//       comp_bonus[2]  -= 10;  // crochetage
//       comp_bonus[3]  -= 20;  // mouvement silencieux
//       comp_bonus[8]  -= 15;  // évasion
//       comp_bonus[9]  -= 10;  // escalade
//       comp_bonus[12] -= 10;  // creuser des tunnels
//       comp_bonus[13] -= 10;  // se cacher dans l'ombre
//       comp_bonus[16] -= 10;  // trouver et désamorcer les pièges
//       comp_bonus[17] -= 15;  // vol à la tire
//       break;
//     case 10:
//       comp_bonus[2]  -= 5;   // crochetage
//       comp_bonus[3]  -= 15;  // mouvement silencieux
//       comp_bonus[8]  -= 10;  // évasion
//       comp_bonus[9]  -= 5;   // escalade
//       comp_bonus[12] -= 5;   // creuser des tunnels
//       comp_bonus[13] -= 5;   // se cacher dans l'ombre
//       comp_bonus[16] -= 10;  // trouver et désamorcer les pièges
//       comp_bonus[17] -= 10;  // vol à la tire
//       break;
//     case 11:
//       comp_bonus[3]  -= 10;  // mouvement silencieux
//       comp_bonus[8]  -= 5;   // évasion
//       comp_bonus[16] -= 5;   // trouver et désamorcer les pièges
//       comp_bonus[17] -= 5;   // vol à la tire
//       break;
//     case 12:
//       comp_bonus[3]  -= 5;   // mouvement silencieux
//       break;
//     case 16:
//       comp_bonus[2]  += 5;   // crochetage
//       break;
//     case 17:
//       comp_bonus[2]  += 10;  // crochetage
//       comp_bonus[3]  += 5;   // mouvement silencieux
//       comp_bonus[8]  += 5;   // évasion
//       comp_bonus[9]  += 5;   // escalade
//       comp_bonus[13] += 5;   // se cacher dans l'ombre
//       comp_bonus[17] += 5;   // vol à la tire
//       break;
//     case 18:
//       comp_bonus[2]  += 15;  // crochetage
//       comp_bonus[3]  += 10;  // mouvement silencieux
//       comp_bonus[8]  += 10;  // évasion
//       comp_bonus[9]  += 10;  // escalade
//       comp_bonus[12] += 5;   // creuser des tunnels
//       comp_bonus[13] += 10;  // se cacher dans l'ombre
//       comp_bonus[16] += 5;   // trouver et désamorcer les pièges
//       comp_bonus[17] += 10;  // vol à la tire
//       break;
//     case 19:
//       comp_bonus[2]  += 20;  // crochetage
//       comp_bonus[3]  += 15;  // mouvement silencieux
//       comp_bonus[8]  += 15;  // évasion
//       comp_bonus[9]  += 15;  // escalade
//       comp_bonus[12] += 10;  // creuser des tunnels
//       comp_bonus[13] += 15;  // se cacher dans l'ombre
//       comp_bonus[16] += 10;  // trouver et désamorcer les pièges
//       comp_bonus[17] += 15;  // vol à la tire
//       break;
//     case 20:
//       comp_bonus[2]  += 20;  // crochetage
//       comp_bonus[3]  += 15;  // mouvement silencieux
//       comp_bonus[8]  += 20;  // évasion
//       comp_bonus[9]  += 20;  // escalade
//       comp_bonus[12] += 15;  // creuser des tunnels
//       comp_bonus[13] += 20;  // se cacher dans l'ombre
//       comp_bonus[16] += 15;  // trouver et désamorcer les pièges
//       comp_bonus[17] += 20;  // vol à la tire
//       break;
//     case 21:
//       comp_bonus[2]  += 25;  // crochetage
//       comp_bonus[3]  += 20;  // mouvement silencieux
//       comp_bonus[8]  += 25;  // évasion
//       comp_bonus[9]  += 20;  // escalade
//       comp_bonus[12] += 20;  // creuser des tunnels
//       comp_bonus[13] += 25;  // se cacher dans l'ombre
//       comp_bonus[16] += 20;  // trouver et désamorcer les pièges
//       comp_bonus[17] += 20;  // vol à la tire
//       break;
//     case 22:
//       comp_bonus[2]  += 25;  // crochetage
//       comp_bonus[3]  += 20;  // mouvement silencieux
//       comp_bonus[8]  += 30;  // évasion
//       comp_bonus[9]  += 25;  // escalade
//       comp_bonus[12] += 30;  // creuser des tunnels
//       comp_bonus[13] += 30;  // se cacher dans l'ombre
//       comp_bonus[16] += 20;  // trouver et désamorcer les pièges
//       comp_bonus[17] += 25;  // vol à la tire
//       break;
//     }

  map< unsigned int, unsigned int > correspondance = map_list_of
    ( 1,  0)
    ( 2,  1)
    ( 3,  2)
    ( 4,  3)
    ( 5,  4)
    ( 6,  5)
    ( 8,  6)
    ( 9,  7)
    (11,  8)
    (12,  9)
    (13, 10)
    (16, 11)
    (17, 12);

  unsigned int combien_comp(Comp_classe.size()), valeur;
  for (unsigned int i(0); i< combien_comp; i++)
    {
      valeur = Comp_classe[i];
      if (Comp[valeur].Pourcentage)
	{
	  Comp_classe[i + 1] += comp_bonus -> at( correspondance[valeur] );
	  i++;
	}
    }

  Debug::depileNiveau();
}

/**
 * Ici on peut augmenter les talents liés à un pourcentage à chaque
 * passage de niveau et à la création.
 *
 * Une sauvegarde de l'état courant est faite avant de modifier quoi
 * que ce soit, et ensuite on afiche un récapitulatif des changements,
 * qui doivent être validés.
 */
void Voleur::augmenterTalents(const bool& lvl_up)
{
  Debug::empileNiveau( &fonction );
  func() << "Voleur::augmenterTalents -> " << endreq;
  // 30 pts si augmente niveau
  vector<unsigned int> quelle, combien;
  unsigned int taille( getCombien() ), nbr( 0 ), depense, laquelle;

  unsigned int bonus( getPourcent( lvl_up ) );

  for (unsigned int i(0); i<taille; i++)
    {
      debug() << Comp_classe[i];
      if (Comp[Comp_classe[i]].Pourcentage)
	{
	  debug() << " -> oui";
	  quelle.push_back(Comp_classe[i]);
	  combien.push_back(Comp_classe[i+1]);
	  i++;
	  nbr++;
	}
      debug() << endreq;
    }

  unsigned int pps(bonus);
  if (lvl_up)
    pps = 30;
  blank() << "Tu as " << pps << " point à dépenser dans les compétences";
  blank() <<" suivantes:" << endreq;
  for (unsigned int i(0); i<nbr; i++)
    {
      debug() << quelle[i] << " => " << Comp[quelle[i]].Comp << endreq;
      blank() << i+1 << " " << Comp[quelle[i]].Comp << " " << combien[i] 
		  << "%" << endreq;
    }

  string poubelle;

  do
    {
      laquelle =
	demanderUnsignedBorne("Quelle compétence veux-tu améliorer? ", 1,
				nbr + 1);

      depense = demanderUnsignedBorne("De combien? ", 0, pps);

      combien[laquelle-1] += depense;
      pps -= depense;
    }
  while(pps!=0);

  vector<unsigned int> tmp;
  unsigned int j(0);

  // On va netoyer tt ça, pas besoin de faire une copie... ou alors demander
  // confirmation!
  for (unsigned int i(0); i<taille; i++)
    {
      if (Comp[Comp_classe[i]].Pourcentage)
	{
	  tmp.push_back(Comp_classe[i]);
	  tmp.push_back(combien[j]);
	  j++;
	  i++;
	}
      else
	tmp.push_back(Comp_classe[i]);
    }
  Comp_classe.clear();
   for (unsigned int i(0); i<taille; i++)
     Comp_classe.push_back(tmp[i]);
  
  func() << "Voleur::augmenterTalents -> " << endreq;
  Debug::depileNiveau();
}

void Voleur::getJS(unsigned int *tab) const
{
  *(tab + 0) = 13; // Paralysie, Poison ou Mort magique
  *(tab + 1) = 14; // Bâton, batonnet baguette
  *(tab + 2) = 12; // Pétrification ou Métamorphose
  *(tab + 3) = 16; // Souffles
  *(tab + 4) = 15; // Sorts
  
  unsigned int cat;
  if (Niveau <= 4)
    cat = 0;
  else  if (Niveau <= 8)
    cat = 1;
  else  if (Niveau <= 12)
    cat = 2;
  else  if (Niveau <= 16)
    cat = 3;
  else  if (Niveau <= 20)
    cat = 4;
  else
    cat = 5;

  *(tab + 0) -= cat;
  *(tab + 1) -= 2 * cat;
  *(tab + 2) -= cat;
  *(tab + 3) -= cat;
  *(tab + 4) -= 2 * cat;
}

// string Voleur::getCompetence(const unsigned int& i) const
// {
//   Debug::empileNiveau( &fonction );
//   //DebugLevelType etat_precedent(dout.getLevel());
//   //dout.setLevel(fonction);
//   debug() << "Compétence numéro " << i << endreq;
//   if (Comp[getComp(i)].Pourcentage)
//     {
//       Debug::depileNiveau();//dout.setLevel(etat_precedent);
//       return " " + Comp[getComp(i)].Comp + " " + ecrireString(getComp(i+1))
// 	+ "\\%";
//     }
//   else
//     {
//       Debug::depileNiveau();//dout.setLevel(etat_precedent);
//       return Comp[getComp(i)].Comp;
//     }
// }

unsigned int Voleur::calculeTAc0() const
{
  unsigned int mod_niveau((Niveau - 1) / 2);

  return 20 - mod_niveau;
}

void Voleur::calculNivMag()
{
  Niveau_mag = 0;
}

/**
 * Les Voleurs n'ont pas de sorts, alors c'est facile !
 */
// void Voleur::ecrireSorts(const string& nom_fichier, const bool& ecrase) const
// {
//   Debug::empileNiveau( &fonction );
//   //DebugLevelType etat_precedent(dout.getLevel());
//   //dout.setLevel(fonction);
//   debug() << "Rien à faire" << endl << flush;
//   ofstream sortie;
//   if (ecrase)
//     sortie.open(nom_fichier.c_str());
//   else
//     sortie.open(nom_fichier.c_str(), ios::app);
//   sortie << "%"  << getClasse() << endl << "% rien à dire" << endreq;
//   sortie.close();
//   Debug::depileNiveau();//dout.setLevel(etat_precedent);
// }

// void Voleur::nbrSort(unsigned int sorts[], const unsigned int& taille) const
// {
//   Debug::empileNiveau( &fonction );
//   //DebugLevelType etat_precedent(dout.getLevel());
//   //dout.setLevel(fonction);
//   debug() << "Rien à faire, mais proprement" << endreq;
//   Debug::depileNiveau();//dout.setLevel(etat_precedent);
// }

/**
 * Permet de gérer les compétences martiales, càd lesquelles sont accessibles
 * à quel coût.
 *
 * Un Voleur peut prendre un arme réservée au Voleur pour 3 pp, ou alors une
 * arme de Guerrier pour 4 pp.
 */
void Voleur::getPrixAcces(map<string, unsigned int>*& Map) const
{
  Debug::empileNiveau( &fonction );
  //DebugLevelType etat_precedent(dout.getLevel());
  //dout.setLevel(fonction);
  func() << "Voleur::getPrixAcces -> début" << endreq;

  map<string, unsigned int>::const_iterator mapIt, mapBegin(Map -> begin()),
    mapEnd(Map -> end());

  for (mapIt = mapBegin; mapIt != mapEnd; mapIt++)
    lfunc() << mapIt -> first << endreq;

  
  mapIt = Map -> find("Voleur");
  if ((mapIt != mapEnd && mapIt -> second > 3) || mapIt == mapEnd)
    Map -> operator[]("Voleur")   = 3;
    mapIt = Map -> find("Guerrier");
    if ((mapIt != mapEnd && mapIt -> second > 4) || mapIt == mapEnd)
    Map -> operator[]("Guerrier") = 4;

  func() << "Voleur::getPrixAcces -> fin" << endreq;
  Debug::depileNiveau();//dout.setLevel(etat_precedent);
}


unsigned int Voleur::getPourcent(const bool& lvlUp) const
{
  if ( lvlUp )
    return 30;
  else
    return 60;
}

string Voleur::getScoreAdditionnel(const unsigned int& i) const
{
  Debug::empileNiveau( &fonction );
  func() << "Voleur::getScoreAdditionnel -> début" << endreq;

  string resultat( "" );

  if ( Comp[ i ].Comp == "Attaque sournoise" )
    {
      switch( Niveau )
	{
	case 1:
	case 2:
	case 3:
	case 4:
	  resultat = "dégâts x2";
	  break;
	case 5:
	case 6:
	case 7:
	case 8:
	  resultat = "dégâts x3";
	  break;
	case 9:
	case 10:
	case 11:
	case 12:
	  resultat = "dégâts x4";
	  break;
	default:
	  resultat = "dégâts x5";
	}
    }
  else if ( Comp[ i ].Comp == "Utilisation de parchemins (niv 10)" ||
	    Comp[ i ].Comp == "Utilisation de parchemins" )
    {
      switch( Niveau )
	{
	case 1:
	case 2:
	  resultat = "10";
	  break;
	case 3:
	case 4:
	  resultat = "20";
	  break;
	case 5:
	case 6:
	  resultat = "30";
	  break;
	case 7:
	  resultat = "40";
	  break;
	case 8:
	  resultat = "50";
	  break;
	case 9:
	  resultat = "60";
	  break;
	case 10:
	  resultat = "70";
	  break;
	default:
	  resultat = "80";
	}
    }

  func() << "Voleur::getScoreAdditionnel -> fin" << endreq;
  Debug::depileNiveau();

  return resultat;
}
